#include <iostream>
#include <cstdio>
#include <cstring>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>

// 基本信息PutName大小
#define PUTSIZE 1024
// 获取命令行变量Command大小
#define COMMANDSIZE 1024
// 打印格式
#define PUTFOEM "[%s@%s %s] # "

// 我们的环境变量表
#define MAX_ENVS 120
char* g_env[MAX_ENVS];
int g_envs = 0;

// 我们的命令行参数表
#define MAX_ARGV 128
char* g_argv[MAX_ARGV];
int g_argc = 0;

// 实时获取cwd
char cwd[1024];
// 更新env的cwd
char cwdenv[1024];

// 上一次的退出码
int lastcode = 0;

// 4. 关于重定向，我们关心的内容
#define NONE_REDIR 0        // 无
#define INPUT_REDIR 1       // <
#define OUTPUT_REDIR 2      // >
#define APPEND_REDIR 3      // >>
int redir = NONE_REDIR;
std::string filename;

/* 获取父进程的环境变量表 */
void Init_Env()
{
    extern char**  environ; // 全局环境变量表
    memset(g_env, 0, sizeof(g_env)); // 初始化我们的环境变量表
    g_envs = 0;

    /* 获取父进程环境变量表的内容 */
    for(int i = 0; environ[i]; i++)
    {
        // 1. 申请空间
        g_env[i] = (char*)malloc(strlen(environ[i]) + 1);
        // 2. 拷贝内容
        strcpy(g_env[i], environ[i]);
        g_envs++;
    }
    // 标志
    g_env[g_envs++] = (char*)"MyShell = Ouyang Test";
    // 最后结尾以NULL
    g_env[g_envs] = NULL;
    
    /* 导入环境变量 */
    for(int i = 0; g_env[i]; ++i)
        putenv(g_env[i]);
    // 更改指向
    environ = g_env;
}

/* 测试环境变量是否导入成功 */
void Print_env()
{
    extern char** environ;
    for(int i = 0; environ[i]; ++i)
        printf("%d->%s\n", i, environ[i]);
}

/* 用户名 / 主机名 / 绝对路径 / 家目录 */
const char* Get_User()
{
    const char* GU = getenv("USER");
    return GU == NULL ? "None" : GU;
}

const char* Get_Hostname()
{
    const char* GH = getenv("HOSTNAME");
    return GH == NULL ? "None" : GH;
}

const char* Get_PWD()
{
    // const char* GP = getenv("PWD");
    const char* GP = getcwd(cwd, sizeof(cwd));
    if(GP != NULL)
    {
        snprintf(cwdenv, sizeof(cwdenv), "PWD=%s", cwd);
        putenv(cwdenv);
    }
    return GP == NULL ? "None" : GP;
}

const char* Get_Home()
{
     const char* Home = getenv("HOME"); 
    return Home == NULL ? "None" : Home;
}

const char* Get_Oldpwd()
{
    const char* old_pwd = getenv("OLDPWD");
    return old_pwd == NULL ? "None" : old_pwd;
}

/* 获取相对路径 */
std::string DirName(const char* pwd)
{
#define SLASHE "/"
    std::string rp = pwd;
    if(rp == SLASHE) return SLASHE;
    /* 找到最后的"/"位置 */
    auto pos = rp.rfind(SLASHE);
    if(pos == std::string::npos) return "Get P_Path Fail!";
    return rp.substr(pos + 1);
}

/* 基本信息的打印 */
void PutBaseInformation()
{
    fflush(stdout);
    char PutName[PUTSIZE];
    const char* pwd = Get_PWD();
    snprintf(PutName, sizeof(PutName), PUTFOEM, Get_User(), Get_Hostname(), DirName(pwd).c_str());
    printf("%s", PutName);
    fflush(stdout);
}

/* 获取命令行 */
bool GetCommandLine(char* out, int size)
{
    // "ls -a -l \n" -> "ls -a -l"
    if(fgets(out, size, stdin) == nullptr) return false;
    out[strlen(out) - 1] = 0; // 清理"/n"
    return strlen(out) > 0; // 没有命令输入不做处理
}


/* 解析命令 */
bool CommandPrase(char* out)
{
    // "ls -a -l" -> "ls" "-a" "-l"
    // 以" "为分隔符
#define SPACE " "
    g_argc = 0; // 重置
    g_argv[g_argc++] = strtok(out, SPACE);
    while((bool)(g_argv[g_argc++] = strtok(NULL, SPACE)));
    g_argc--; // 减去多余的++
    return g_argc > 0;
}

/* 打印测试g_argv */
void Print_Argv()
{
    for(int i = 0; g_argv[i]; ++i)
        printf("g_argv[%d]->%s", i, g_argv[i]);
}


/* Cd */
void Cd()
{
    // Cd / Cd - / Cd ~
    if(g_argc == 1)
    {
        // Cd
        std::string home = Get_Home();
        if(home.empty()) return;
        chdir(home.c_str());
    }
    else{
        // Cd - / Cd ~
        std::string op = g_argv[1];
        if(op == "~")
        {
            // 家目录
            chdir(Get_Home());
        }
        else if(op == "-")
        {
            // 之前目录
            chdir(Get_Oldpwd());
        }
        else{
            chdir(op.c_str());
        }
    }
}

/* Echo */
void Echo()
{
    if(g_argc == 2 && !(g_argc > 2))
    {
        // echo $?
        // echo "Hello"
        // echo $PATH
        std::string opt = g_argv[1];
        if(opt == "$?")
        {
            std::cout << lastcode << std::endl;
            lastcode = 0;
        }
        else if(opt[0] == '$')
        {
            std::string env_name = opt.substr(1);
            char* env = getenv(env_name.c_str());
            if(env)
                std::cout << env << std::endl;
        }
        else{
            std::cout << opt << std::endl;
        }
    }
}

/* 特殊处理内建命令 */
bool CheckAndExecBuiltin()
{
    std::string cmd = g_argv[0];
    if(cmd == "cd")
    {
        Cd();
        return true;
    }
    else if(cmd == "echo")
    {
        Echo();
        return true;
    }
    // ...
    return false;
}

void TrimSpace(char cmd[], int &end)
{
    while(isspace(cmd[end]))
    {
        end++;
    }
}

bool CheckRedirect()
{
    redir = NONE_REDIR;
    filename.clear();
    for (int i = 0; g_argv[i] != NULL; ++i)
    {
        if (strcmp(g_argv[i], "<") == 0)
        {
            redir = INPUT_REDIR;
            if (g_argv[i + 1] != NULL)
            {
                filename = g_argv[i + 1];
                g_argv[i] = NULL; // 截断参数列表
                return true;
            }
            return false;
        }
        else if (strcmp(g_argv[i], ">") == 0)
        {
            redir = OUTPUT_REDIR;
            if (g_argv[i + 1] != NULL)
            {
                filename = g_argv[i + 1];
                g_argv[i] = NULL; // 截断参数列表
                return true;
            }
            return false;
        }
        else if (strcmp(g_argv[i], ">>") == 0)
        {
            redir = APPEND_REDIR;
            if (g_argv[i + 1] != NULL)
            {
                filename = g_argv[i + 1];
                g_argv[i] = NULL; // 截断参数列表
                return true;
            }
            return false;
        }
    }
    return false;
}

/* 命令执行 */
int Execute()
{
    // 进程创建 + 进程替换
    pid_t id = fork();
    if(id == 0)
    {
        int fd = -1;
        // 子进程检测重定向情况
        if(redir == INPUT_REDIR)
        {
            fd = open(filename.c_str(), O_RDONLY);
            if(fd < 0) exit(1);
            dup2(fd, 0);
            close(fd);
        }
        else if(redir == OUTPUT_REDIR)
        { 
            umask(0);
            fd = open(filename.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0666);
            if(fd < 0) exit(2);
            dup2(fd, 1);
            close(fd);
        }
        else if(redir == APPEND_REDIR)
        {
            umask(0);
            fd = open(filename.c_str(), O_CREAT | O_WRONLY | O_APPEND, 0666);
            if(fd < 0) exit(2);
            dup2(fd, 1);
            close(fd);
        }
        // child
        execvp(g_argv[0], g_argv);
        exit(EXIT_FAILURE);
    }

    // father
    // 进程等待
    int st = 0;
    pid_t pid = waitpid(id, &st, 0);
    lastcode = WEXITSTATUS(st);
    return pid;
}


int main()
{
    /* 初始化我们的环境变量 */
      Init_Env();
   //  Print_env(); /* 测试Env */
    while(true)
    {
        /* 基本信息的打印 */
        PutBaseInformation();
        
        /* 命令行的获取 */
        char CommandLine[COMMANDSIZE];
        if(!GetCommandLine(CommandLine, sizeof(CommandLine)))
            continue;
        
        /* 解析命令 */
        if(!CommandPrase(CommandLine))
            continue; 
        
        /* 重定向分析 */
        if(CheckRedirect())
        {
            Execute();
            continue;
        }
        
        /*  特殊处理内建命令 */
        if(CheckAndExecBuiltin())
            continue;
        
        // 命令执行
        Execute();
    }
    return 0;
}
